{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Copy of MVNN_Prototype.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AyushGupta51379/COMP_5331_Project_Fake_News_Detection/blob/master/MVNN_Prototype.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ghzNr1TklPAR"
      },
      "source": [
        "# MVNN\n",
        "\n",
        "This piece of work is an implementation of Multi-domain Visual Neural Network (MVNN), which is first proposed in the paper [Exploiting Multi-domain Visual Information for Fake News Detection](https://arxiv.org/abs/1908.04472)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vYmmpTvxlII9"
      },
      "source": [
        "# some basic things to include\n",
        "import os\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torchvision import datasets, transforms\n",
        "\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "\n",
        "# some preprocessing techniques\n",
        "from scipy.fftpack import dct\n",
        "\n",
        "# custom dataset\n",
        "from torch.utils.data.dataset import Dataset\n",
        "\n",
        "# this is only required for Google Colab\n",
        "from google.colab import drive\n",
        "\n",
        "import time\n",
        "from datetime import datetime\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsuzqnBVpuAR"
      },
      "source": [
        "these modules and dataset require to be downloaded (unless they are executed under a repository)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iCbaTVoCPyWo",
        "outputId": "3e08e6f5-500e-4123-b196-ef40cdcfbaef",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Mount your google drive (for later model saving & loading)\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OsFX9EkSmXxF",
        "outputId": "2f690b00-2642-4d06-8cf9-693a86a0d7ef",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# DCT modules\n",
        "#print(\"DCT Module:\")\n",
        "#!gdown --id 1MtVZXrFkLTLQgOhFhbYIUrXT-FMKH2hH\n",
        "#from dct import DCT, DFT\n",
        "\n",
        "# download the Weibo dataset\n",
        "!gdown --id 1gjbSZV5NjjIVOqSP-yTCqXcGPX9PnYn5\n",
        "!unzip -q '/content/MM17-WeiboRumorSet.zip'\n",
        "mainfolder = 'MM17-WeiboRumorSet/'\n",
        "subfolders = {'nonrumor_images': 0, 'rumor_images': 1}\n",
        "print(\"Dataset: Weibo is loaded\")\n",
        "\n",
        "# download the Twitter dataset\n",
        "# !gdown --id 1ydEupxLKCmFYe3nfbpbRyCmHi05Oxt5i\n",
        "# !unzip -q '/content/Medieval2015_fake_or_real_Images.zip'\n",
        "# mainfolder = 'Medieval2015_fake_or_real_Images/'\n",
        "# subfolders = {'non-rumor': 0, 'rumor': 1}\n",
        "# print(\"Dataset: Twitter is loaded\")"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1gjbSZV5NjjIVOqSP-yTCqXcGPX9PnYn5\n",
            "To: /content/MM17-WeiboRumorSet.zip\n",
            "1.35GB [00:16, 81.7MB/s]\n",
            "Dataset: Weibo is loaded\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLz9GPSIgczE"
      },
      "source": [
        "\n",
        "'''\n",
        "Usage:\n",
        "as image preprocessor by calling DCT() as a transform\n",
        "\n",
        "input: 128*128*3 PIL image\n",
        "output: 64*256 torch array (histogram)\n",
        "\n",
        "[128*128] => (crop) => [256 * [8*8]] => (DCT_2d) => [256 * [8 * 8]] => reshape => [256 * 64]  \n",
        "'''\n",
        "\n",
        "class DCT(object):\n",
        "    def __init__(self):\n",
        "        self.BLOCK_HEIGHT = 8\n",
        "        self.BLOCK_WIDTH = 8\n",
        "        self.BLOCK_SIZE = (self.BLOCK_HEIGHT, self.BLOCK_WIDTH)\n",
        "\n",
        "    def div_block(self, img, block_size):\n",
        "        img_height = img.height\n",
        "        img_width = img.width\n",
        "        block_height = block_size[0]\n",
        "        block_width = block_size[1]\n",
        "        assert(img_height % block_height == 0)\n",
        "        assert(img_width % block_width == 0)\n",
        "\n",
        "        blocks = []\n",
        "        for i in range(0,img_height,block_height):\n",
        "            for j in range(0,img_width,block_width):\n",
        "                box = (j, i, j+block_width, i+block_height)\n",
        "                block = np.array(img.crop(box))\n",
        "                blocks.append(block)\n",
        "        return np.array(blocks)\n",
        "\n",
        "    def dct2(self, array_2d):\n",
        "        return dct(dct(array_2d.T, norm = 'ortho').T, norm = 'ortho')\n",
        "\n",
        "    def _dct2(self, array_2d):\n",
        "        return dct(dct(array_2d, norm = 'ortho').T, norm = 'ortho').T\n",
        "\n",
        "    def __call__(self, img):\n",
        "        image = img\n",
        "        blocks = self.div_block(image, self.BLOCK_SIZE)\n",
        "        b_blocks, g_blocks, r_blocks = blocks[:, :, :, 0], blocks[:, :, :, 1], blocks[:, :, :, 2]\n",
        "        test_blocks = (b_blocks + g_blocks + r_blocks) / 3 # naive greyscale\n",
        "        result = np.array([self._dct2(test_block) for test_block in test_blocks])\n",
        "        # return a torch.tensor\n",
        "        return torch.from_numpy(result.reshape(256, 64).T).float()\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Simply DCT. What do you expect?\"\n",
        "\n",
        "'''\n",
        "Usage: Same as DCT()\n",
        "\n",
        "input: 64*256 torch array (histogram)\n",
        "output: 64*256 torch array (frequency histogram)\n",
        "'''\n",
        "class DFT(object):\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __call__(self, freq):\n",
        "        # convert into complex form containing real and imaginary part\n",
        "        cmplx = torch.from_numpy(np.zeros((freq.shape[0], freq.shape[1], 2)))\n",
        "        cmplx[:, :, 0] += freq\n",
        "        out = torch.fft(cmplx, 1, normalized=True)[:, :, 0]\n",
        "        return out\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Simply DFT. What do you expect?\"\n",
        "\n",
        "\n",
        "'''\n",
        "input: PIL loaded image\n",
        "output: PIL image, in YCbCr color space\n",
        "'''\n",
        "class Ycbcr_convert():\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __call__(self, img):\n",
        "        return img.convert('YCbCr')\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Convert a PIL Image from RGB to YCbCr\" "
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ayTY1AY3miLq"
      },
      "source": [
        "## Image transformers for pixel and freq domain"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AeTQn2uZmX2r"
      },
      "source": [
        "## Define the image transformers for pixel and freq domain\n",
        "\n",
        "image_height_pixel, image_width_pixel = 224, 224\n",
        "image_height_freq, image_width_freq = 128, 128\n",
        "tform_pixel = transforms.Compose([\n",
        "    transforms.Resize((image_height_pixel,image_width_pixel), interpolation=Image.BICUBIC),\n",
        "    transforms.ToTensor()\n",
        "])\n",
        "tform_freq = transforms.Compose([\n",
        "    transforms.Resize((image_height_freq,image_width_freq), interpolation=Image.BICUBIC),\n",
        "    Ycbcr_convert(),\n",
        "    DCT(),\n",
        "    # DFT()\n",
        "])\n",
        "\n",
        "def imshow(np_image):\n",
        "    plt.figure(figsize = (5,5))\n",
        "    plt.imshow(np_image) # it should be a numpy array\n",
        "    plt.show()"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4nas4CoTsRqC"
      },
      "source": [
        "### Some remarks from AG  \n",
        "When you use GPU runtime in Colab, apart from the original VM running the notebook, Google will instantiate a new VM with GPU so that parallel computations are forwarded to VM with GPU. \\\\\n",
        "Here we load all the data (~1.35GB, while Nvidia Tesla K80 has 12GB RAM) into memory in the beginning. Hence the data transfer between 2 VMs will only be called once, rather than every mini-batch. This is the point which takes most time, while in the training section later it will exhibit huge speedup."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4sNJgGvkmX5z"
      },
      "source": [
        "class WeiboRumorDataset(Dataset):\n",
        "    def __init__(self, tform_pixel, tform_freq, folder, subfolders):        \n",
        "        self.tform_pixel = tform_pixel\n",
        "        self.tform_freq = tform_freq\n",
        "        self.mainfolder = folder\n",
        "        self.subfolders = subfolders        \n",
        "        self.data = []\n",
        "        # load the entire dataset into memory\n",
        "        for subfolder, label in subfolders.items():\n",
        "            current = os.path.join(self.mainfolder, subfolder)\n",
        "            filenames = os.listdir(current)\n",
        "            for filename in filenames:\n",
        "                self.data.append([os.path.join(subfolder, filename), label])\n",
        "            print(\"[%s]: %d image loaded.\" % (current, len(filenames)))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        if torch.is_tensor(idx):\n",
        "            idx = idx.tolist()\n",
        "\n",
        "        filepath, label = self.data[idx]\n",
        "        img = Image.open(os.path.join(self.mainfolder, filepath)).convert('RGB')     \n",
        "        pixel_input = self.tform_pixel(img)\n",
        "        freq_input = self.tform_freq(img)\n",
        "        out = [pixel_input, freq_input, label]\n",
        "        return out"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AxFdeFBD0icA",
        "outputId": "d9ab1aef-9530-4304-d072-8ecdb8aef329",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 408
        }
      },
      "source": [
        "# visualize information of the dataset\n",
        "\n",
        "dataset = WeiboRumorDataset(tform_pixel, tform_freq, mainfolder, subfolders)\n",
        "count = dataset.__len__()\n",
        "print('Total no. of images: ', count)\n",
        "\n",
        "pixel_input, freq_input, label = dataset.__getitem__(0)\n",
        "imshow(pixel_input.transpose(0, 1).transpose(1, 2))\n",
        "print(\"Frequency domain shape:\", freq_input.shape)\n",
        "print(\"Label:\", label)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[MM17-WeiboRumorSet/nonrumor_images]: 5318 image loaded.\n",
            "[MM17-WeiboRumorSet/rumor_images]: 7954 image loaded.\n",
            "Total no. of images:  13272\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Frequency domain shape: torch.Size([64, 256])\n",
            "Label: 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xsxqK2wRlNvD"
      },
      "source": [
        "## Subnetworks"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iSzJzDbwsKAt"
      },
      "source": [
        "class CNN(nn.Module):\n",
        "    def __init__(self, image_height, image_width):\n",
        "        super(CNN, self).__init__()\n",
        "\n",
        "        # NOTE:\n",
        "        # 1. Before each ReLu, a BatchNorm2d layer is added to accelerate convergence (also did by the authors of the paper)\n",
        "\n",
        "        # Conv Model 1\n",
        "        self.conv_M1 = nn.Sequential(nn.Conv2d( 3, 32, 3, padding = 1), nn.BatchNorm2d(32), nn.ReLU(),   # (N,  3, 128, 128) --> (N, 32, 128, 128); add padding = 1 for kernel size = 3 to avoid changing output size\n",
        "                                     nn.Conv2d(32, 32, 1), nn.BatchNorm2d(32), nn.ReLU(),                # (N, 32, 128, 128) --> (N, 32, 128, 128);\n",
        "                                     nn.MaxPool2d(2))                                                    # (N,  3, 128, 128) --> (N, 32,  64,  64);\n",
        "                                     \n",
        "        # Conv Model 2\n",
        "        self.conv_M2 = nn.Sequential(nn.Conv2d(32, 64, 3, padding = 1), nn.BatchNorm2d(64), nn.ReLU(),  # (N, 32, 64, 64) --> (N, 64, 64, 64)\n",
        "                                     nn.Conv2d(64, 64, 1), nn.BatchNorm2d(64), nn.ReLU(),               # (N, 64, 64, 64) --> (N, 64, 64, 64)\n",
        "                                     nn.MaxPool2d(2))                                                   # (N, 64, 64, 64) --> (N, 64, 32, 32)\n",
        "\n",
        "        # Conv Model 3\n",
        "        self.conv_M3 = nn.Sequential(nn.Conv2d(64, 64, 3, padding = 1), nn.BatchNorm2d(64), nn.ReLU(),  # (N, 64, 32, 32) --> (N, 64, 32, 32)\n",
        "                                     nn.Conv2d(64, 64, 1), nn.BatchNorm2d(64), nn.ReLU(),               # (N, 64, 32, 32) --> (N, 64, 32, 32)\n",
        "                                     nn.MaxPool2d(2))                                                   # (N, 64, 32, 32) --> (N, 64, 16, 16)\n",
        "\n",
        "        # Conv Model 4\n",
        "        self.conv_M4 = nn.Sequential(nn.Conv2d( 64, 128, 3, padding = 1), nn.BatchNorm2d(128), nn.ReLU(), # (N,  64, 16, 16) --> (N, 128, 16, 16)\n",
        "                                     nn.Conv2d(128, 128, 1), nn.BatchNorm2d(128), nn.ReLU(),              # (N, 128, 16, 16) --> (N, 128, 16, 16)\n",
        "                                     nn.MaxPool2d(2))                                                     # (N, 128, 16, 16) --> (N, 128,  8,  8)\n",
        "        \n",
        "        #===== For each branch =====%\n",
        "        # Note:\n",
        "        # 1. Flatten convolution layer before FC layer, the input column size = 64 neurons * pooled output size\n",
        "        # 2. Since image_height and image_width are fed from outside, we need to ensure the type to int after division, otherwise gives bugs.\n",
        "        # 3. Need to add a dropout layer with a prob of 0.5 after FC layer (see the reference paper)\n",
        "        # 4. Before each FC layer, a BatchNorm2d layer is added to accelerate convergence\n",
        "\n",
        "        self.conv_br1 = nn.Sequential(nn.Conv2d(32, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),    # flatten from the 2nd dim (1) to the last dim (-1)\n",
        "                                      nn.Linear(int(64*image_height*image_width/2/2), 64),\n",
        "                                      nn.BatchNorm1d(64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br2 = nn.Sequential(nn.Conv2d(64, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),              \n",
        "                                      nn.Linear(int(64*image_height*image_width/4/4), 64),\n",
        "                                      nn.BatchNorm1d(64),  \n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br3 = nn.Sequential(nn.Conv2d(64, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),    \n",
        "                                      nn.Linear(int(64*image_height*image_width/8/8), 64),\n",
        "                                      nn.BatchNorm1d(64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br4 = nn.Sequential(nn.Conv2d(128, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),              \n",
        "                                      nn.Linear(int(64*image_height*image_width/16/16), 64),\n",
        "                                      nn.BatchNorm1d(64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        # FC layer to 2 classes (fake or real) with Softmax to compute prob along the dimension of concatenated features (64*4 = 256)\n",
        "        self.fc = nn.Sequential(nn.Linear(256, 2),\n",
        "                                nn.Dropout(0.5))    \n",
        "                                        #nn.Softmax(dim=1)) # AG: no need for softmax if we use cross entropy loss function, which will also offer prob.\n",
        "                                                            # Now the loss in the training part converges!!\n",
        "    \n",
        "    def forward(self, x):\n",
        "        out1 = self.conv_M1(x)      # Branch 1\n",
        "        out2 = self.conv_M2(out1)   # Branch 2\n",
        "        out3 = self.conv_M3(out2)   # Branch 3\n",
        "        out4 = self.conv_M4(out3)   # Branch 4\n",
        "        v1 = self.conv_br1(out1)\n",
        "        v2 = self.conv_br2(out2)\n",
        "        v3 = self.conv_br3(out3)\n",
        "        v4 = self.conv_br4(out4)\n",
        "        v_cat = torch.cat((v1, v2, v3, v4), dim=1)\n",
        "        # p = self.fc(v_cat)\n",
        "\n",
        "        # print(\"\\n v1 size:\", v1.shape)\n",
        "        # print(\"\\n v2 size:\", v2.shape)\n",
        "        # print(\"\\n v3 size:\", v3.shape)\n",
        "        # print(\"\\n v4 size:\", v4.shape)\n",
        "        # print(\"\\n v_cat size:\", v_cat.shape)\n",
        "        return v1, v2, v3, v4\n",
        "\n",
        "class CNN_GRU(CNN):\n",
        "    def __init__(self, image_height, image_width):\n",
        "        super(CNN_GRU, self).__init__(image_height, image_width)\n",
        "\n",
        "        # The 4 GRUs in layer 1\n",
        "        self.gru1_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru2_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru3_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru4_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "\n",
        "        # The 4 GRUs in layer 2\n",
        "        self.gru1_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru2_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru3_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru4_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "        self.bn = nn.BatchNorm1d(4*2*32)\n",
        "        self.fc = nn.Sequential(nn.Linear(4*2*32, 2))\n",
        "                                            # nn.LogSoftmax(dim=1)) # AG: no need for softmax if we use cross entropy loss function, which will also offer prob.\n",
        "                                                            # Now the loss in the training part converges!!\n",
        "    def forward(self, x):\n",
        "        v1, v2, v3, v4 = super().forward(x)\n",
        "        \n",
        "        v1 = v1.unsqueeze(0) # add an extra dimension to feed into the gru model (4, 64) --> (1, 4, 64)\n",
        "        v2 = v2.unsqueeze(0)\n",
        "        v3 = v3.unsqueeze(0)\n",
        "        v4 = v4.unsqueeze(0)\n",
        "\n",
        "        # backward GRU (1st layer) which reads from v4 to v1 \n",
        "        out4_layer1, h4_backward = self.gru4_1(v4)                  # --> (1, N, 32)\n",
        "        out3_layer1, h3_backward = self.gru3_1(v3, h4_backward)\n",
        "        out2_layer1, h2_backward = self.gru2_1(v2, h3_backward)\n",
        "        out1_layer1, h1_backward = self.gru1_1(v1, h2_backward)\n",
        "\n",
        "\n",
        "        # forward GRU (2nd layer) which reads from v1 to v4 \n",
        "        out1_layer2, h1_forward = self.gru1_2(h1_backward)          # --> (1, N, 32)\n",
        "        out2_layer2, h2_forward = self.gru2_2(h2_backward, h1_backward)\n",
        "        out3_layer2, h3_forward = self.gru3_2(h3_backward, h2_backward)\n",
        "        out4_layer2, h4_forward = self.gru4_2(h4_backward, h3_backward)\n",
        "\n",
        "        # concatenating the forward hidden state and the backward hidden state along the feature dimension --> (1, N, 64)\n",
        "        L1 = torch.squeeze(torch.cat((h1_forward, h1_backward), dim=2)) # --> (N, 64)\n",
        "        L2 = torch.squeeze(torch.cat((h2_forward, h2_backward), dim=2))\n",
        "        L3 = torch.squeeze(torch.cat((h3_forward, h3_backward), dim=2))\n",
        "        L4 = torch.squeeze(torch.cat((h4_forward, h4_backward), dim=2))\n",
        "\n",
        "        # print(\"\\n L1 size:\", L1.shape)\n",
        "        # print(\"\\n L2 size:\", L2.shape)\n",
        "        # print(\"\\n L3 size:\", L3.shape)\n",
        "        # print(\"\\n L4 size:\", L4.shape)\n",
        "\n",
        "        L_cat = torch.cat((L1, L2, L3, L4), dim=1)    # --> (4, N, 32)\n",
        "        # print(\"\\n L_cat size:\", L_cat.shape)\n",
        "        \n",
        "        # p = self.fc(self.bn(L_cat))\n",
        "\n",
        "        return L1, L2, L3, L4, L_cat\n",
        "\n",
        "class Frequent_Domain_Subnetwork(nn.Module):\n",
        "    def __init__(self):\n",
        "            super(Frequent_Domain_Subnetwork, self).__init__()\n",
        "            self.backbone = nn.Sequential(nn.Conv1d(64, 32, 3, padding=1),\n",
        "                                nn.BatchNorm1d(32),\n",
        "                                nn.ReLU(),\n",
        "                                nn.MaxPool1d(2),\n",
        "                                nn.Conv1d(32, 64, 3, padding=1),\n",
        "                                nn.BatchNorm1d(64),\n",
        "                                nn.ReLU(),\n",
        "                                nn.MaxPool1d(2),\n",
        "                                nn.Conv1d(64, 128, 3, padding=1),\n",
        "                                nn.BatchNorm1d(128),\n",
        "                                nn.ReLU(),\n",
        "                                nn.MaxPool1d(2),\n",
        "                                nn.Flatten(),\n",
        "                                nn.Linear(4096, 64),\n",
        "                                nn.ReLU(),\n",
        "                                nn.Linear(64, 64))\n",
        "            \n",
        "    def forward(self, x):\n",
        "        out = self.backbone.forward(x)\n",
        "        return out    "
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GGtmk4wxn8nb"
      },
      "source": [
        "# Models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nkgAG_e7terO"
      },
      "source": [
        "#=========== Model 1, full MVNN model\n",
        "class MVNN(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, L1, L2, L3, L4), dim=1) # Bx5x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx5x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out        \n",
        "\n",
        "#=========== Model 2, w/o freq\n",
        "class MVNN_wout_freq(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        # self.freq_subnet = Frequent_Domain_Subnetwork()     \n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        # L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L1, L2, L3, L4), dim=1) # Bx4x64\n",
        "        # L_all = torch.stack((L0, L1, L2, L3, L4), dim=1) # Bx5x64\n",
        "\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx4x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out      \n",
        "\n",
        "#=========== Model 3, MVNN w/o pixel and attention\n",
        "class MVNN_wout_pixel(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(64, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "\n",
        "        L0 = self.freq_subnet(x_freq)  # Bx64\n",
        "        out = self.Wc(L0) # final output: Bx2\n",
        "        return out\n",
        "\n",
        "\n",
        "#=========== Model 4, full MVNN w/o attention\n",
        "class MVNN_wout_att(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(64*5, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.cat((L0, L1, L2, L3, L4), dim=1) # Bx320\n",
        "        out = self.Wc(L_all) # final output: Bx2\n",
        "        return out\n",
        "\n",
        "#=========== Model 5, MVNN w/o GRU\n",
        "class MVNN_wout_GRU(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN(image_height_pixel, image_width_pixel) #<-- use CNN instead of CNN_GRU\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        v1, v2, v3, v4 = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, v1, v2, v3, v4), dim=1) # Bx5x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx5x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out\n",
        "\n",
        "#=========== Model 6, MVNN w/o branches (and GRU)\n",
        "class MVNN_wout_branches(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN(image_height_pixel, image_width_pixel) #<-- use CNN instead of CNN_GRU\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 2\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        _, _, _, v4 = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, v4), dim=1) # Bx2x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx2x64 bmm 1x64x1 => Bx2x1 => Bx2\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x2 bmm Bx2x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out  "
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3EdG2-b6Yju4"
      },
      "source": [
        "from sklearn.metrics import accuracy_score # normal accuracy\n",
        "from sklearn.metrics import balanced_accuracy_score # used in case of imbalanced data sets, average of recall, from 0 to 1\n",
        "from sklearn.metrics import confusion_matrix # division of performance on the multilabels\n",
        "from sklearn.metrics import cohen_kappa_score # compares model against random prediction, from -1 to 1\n",
        "from sklearn.metrics import classification_report # for multilabel classification, gives precision, recall, f score, support, more\n",
        "\n",
        "def print_metrics(y_true, y_pred, target_names):\n",
        "    print(\"Accuracy:\", accuracy_score(y_true, y_pred))\n",
        "    print(\"Balanced Accuracy:\" , balanced_accuracy_score(y_true, y_pred))\n",
        "    print(\"Confusion Matrix:\\n\", confusion_matrix(y_true, y_pred))\n",
        "    print(\"Cohen Kappa Score:\", cohen_kappa_score(y_true, y_pred))\n",
        "    print(\"Classification Report:\\n\", classification_report(y_true, y_pred, target_names=target_names))\n",
        "\n",
        "#  function to view one image\n",
        "def image_show(np_image):\n",
        "  plt.figure(figsize = (5,5))\n",
        "  plt.imshow(np_image) # it should be a numpy array\n",
        "  plt.show()\n"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EiV4ggkLHI_o"
      },
      "source": [
        "# Hyper-parameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yo68qKXqpUo6"
      },
      "source": [
        "# Hyper-parameters\n",
        "MAX_EPOCH = 300\n",
        "learning_rate = 0.0001 # adopt a small lr to ensure convergence\n",
        "batch_size = 32\n",
        "resumetraining = False\n",
        "\n",
        "print_every = 20\n",
        "test_n_savemodel_every_epoch = 2\n",
        "device = 'cuda'\n",
        "seed_no = 0\n",
        "stop_at_loss = 0.1    #before it was 0.1. But it is not very stable.\n",
        "#================================\n",
        "modelname = 'MVNN_wout_freq'    # Which model to use?\n",
        "#================================"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NvJVbvepOrJA"
      },
      "source": [
        "## Let's Start Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gOea_kRVOwPK",
        "outputId": "17d31b3a-2422-4e60-c921-ac0f92dd4ad3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "torch.set_deterministic = True\n",
        "torch.manual_seed(seed_no) # set seed for reproducibility (still some randomness, not stable...)\n",
        "\n",
        "if modelname == 'MVNN': # hard-coded\n",
        "  model = MVNN(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_freq':\n",
        "  model = MVNN_wout_freq(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_pixel':\n",
        "  model = MVNN_wout_pixel(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_att':\n",
        "  model = MVNN_wout_att(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_GRU':\n",
        "  model = MVNN_wout_GRU(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_branches':\n",
        "  model = MVNN_wout_branches(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "else:\n",
        "  model = []\n",
        "  print(\"Error: the selected model is not available!\")\n",
        "\n",
        "# 80% train, 20% test\n",
        "dataset = WeiboRumorDataset(tform_pixel, tform_freq, mainfolder, subfolders)\n",
        "trainset, testset = torch.utils.data.random_split(dataset, [int(count*0.8), count-int(count*0.8)])\n",
        "print('Total no. of train set images: ', len(trainset))\n",
        "print('Total no. of test set images: ', len(testset))\n",
        "\n",
        "labels = dataset.subfolders # the dataset saves the subfolder's name as the labels\n",
        "classes = list(labels.keys()) # convert dict keys into list\n",
        "print('classes:', classes)\n",
        "\n",
        "# Load training and test sets\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, drop_last=True) \n",
        "# pixel_input, freq_input, label = next(iter(trainloader)) \n",
        "# imshow(pixel_input[1,:,:,:].transpose(0, 1).transpose(1, 2)) # plot figure to check reproduciablility\n",
        "\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=True, drop_last=True) \n",
        "# pixel_input, freq_input, label = next(iter(testloader))\n",
        "# imshow(pixel_input[1,:,:,:].transpose(0, 1).transpose(1, 2)) # plot figure to check reproduciablility\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
        "\n",
        "# Resume the last trained model?\n",
        "#================================\n",
        "resume_epoch = 0\n",
        "if resumetraining == True:\n",
        "  # load the model checkpoint\n",
        "  PATH = ('drive/My Drive/Colab Notebooks/trained_models/' + modelname + \"_MAXepoch\" + str(MAX_EPOCH)\n",
        "          + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_seed' + str(seed_no) + \".pth\")\n",
        "  print('Loading from ', PATH)\n",
        "\n",
        "  checkpoint = torch.load(PATH)\n",
        "  # load model weights state_dict\n",
        "  model.load_state_dict(checkpoint['model_state_dict'])\n",
        "  print('Previously trained model weights state_dict loaded...')\n",
        "\n",
        "  # load trained optimizer state_dict\n",
        "  optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
        "  print('Previously trained optimizer state_dict loaded...')\n",
        "\n",
        "  resume_epoch = checkpoint['epoch']\n",
        "  # load the criterion\n",
        "  criterion = checkpoint['loss']\n",
        "  print('Trained model loss function loaded...')\n",
        "\n",
        "  # load the acc & loss in the previous epochs\n",
        "  epoch_acc = checkpoint['epoch_acc']\n",
        "  epoch_loss = checkpoint['epoch_loss']\n",
        "\n",
        "  print('\\n===== Resuming the Last Training from Epoch %d ... =====' %(resume_epoch))\n",
        "else:\n",
        "  epoch_acc = []\n",
        "  epoch_loss = []\n",
        "  print('\\n===== Start a New Training ... =====')\n",
        "  \n",
        "\n",
        "for epoch in range(MAX_EPOCH - resume_epoch):\n",
        "    total_loss, total_acc = 0, 0\n",
        "    cnt = 0\n",
        "    t0 = time.time()\n",
        "\n",
        "    epoch = epoch + resume_epoch\n",
        "    for i, data in enumerate(trainloader):\n",
        "\n",
        "        Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "        y = data[2].to(device)        \n",
        "\n",
        "        optimizer.zero_grad() \n",
        "        \n",
        "        # forward\n",
        "        out = model(Xp, Xf)        \n",
        "        #print(out, y_pred)\n",
        "        loss = criterion(out, y)\n",
        "\n",
        "        # backward\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # stats\n",
        "        y_pred = torch.argmax(out, dim=1)\n",
        "        total_acc += (y_pred == y).sum().item() / len(y_pred)\n",
        "        total_loss += loss.item()\n",
        "\n",
        "        cnt += 1\n",
        "        if i % print_every == 0:\n",
        "            running_loss = total_loss / cnt\n",
        "            running_acc = total_acc / cnt\n",
        "            # total_acc, total_loss = 0, 0\n",
        "            # cnt = 0\n",
        "            # print(out.T, '\\n', y_pred.T, '\\n', y.T)\n",
        "            print('%s: [Epoch %d] [Iter %d/%d] Running Loss: %5f  Running Acc: %5f' \n",
        "                  %(modelname, epoch+1, i+1, int(len(trainset)/trainloader.batch_size), running_loss, running_acc))\n",
        "\n",
        "    # Store the average acc & loss for each epoch for later plotting\n",
        "    print('Training: Loss = %5f, Acc = %5f' %(running_loss, running_acc))\n",
        "    epoch_acc.append(running_acc)\n",
        "    epoch_loss.append(running_loss)\n",
        "\n",
        "    # Time the training\n",
        "    t1 = time.time()\n",
        "    print(\"Training Time: %10.3f mins\" %((t1-t0)/60))\n",
        "\n",
        "    # Validating\n",
        "    if (epoch+1) % test_n_savemodel_every_epoch == 0:\n",
        "      report_every = 10\n",
        "      test_loss = 0\n",
        "      cnt = 0\n",
        "      model.eval()\n",
        "      y_true = []\n",
        "      y_pred = []\n",
        "      with torch.no_grad():\n",
        "          print('\\n===== Start Validating ... =====')\n",
        "          for data in testloader:\n",
        "              Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "              y = data[2].to(device)\n",
        "\n",
        "              # prediction\n",
        "              out = model(Xp, Xf)        \n",
        "              pred = torch.argmax(out, dim=1)\n",
        "\n",
        "              loss = criterion(out, y)\n",
        "              test_loss += loss.item()\n",
        "\n",
        "              y_true.append(y)\n",
        "              y_pred.append(pred)\n",
        "\n",
        "              cnt += 1\n",
        "\n",
        "              if cnt % report_every == 0:\n",
        "                  print(\"[Test] [Epoch %d]  %d / %d batches tested\" % (epoch+1, cnt, testloader.__len__()))        \n",
        "\n",
        "          test_loss = test_loss/cnt\n",
        "          print(\"[Test] [Epoch %d] %d / %d batches tested. Test Loss: %5f\" % (epoch+1, cnt, testloader.__len__(), test_loss))\n",
        "      model.train() # Toggle on the training mode to enable back the dropout/batchnorm layers for training\n",
        "      \n",
        "      # Print classification report\n",
        "      y_true = torch.cat(y_true, dim=0)\n",
        "      y_pred = torch.cat(y_pred, dim=0)\n",
        "      target_names = ['non-rumor', 'rumor']\n",
        "      print_metrics(y_true.cpu(), y_pred.cpu(), target_names)\n",
        "      print('')\n",
        "\n",
        "      # Save model checkpoint\n",
        "      PATH = ('drive/My Drive/Colab Notebooks/trained_models/' + modelname + \"_MAXepoch\" + str(MAX_EPOCH)\n",
        "              + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_seed' + str(seed_no) + \".pth\")\n",
        "      print(PATH)\n",
        "      torch.save({\n",
        "            'epoch': epoch+1,\n",
        "            'model_state_dict': model.state_dict(),\n",
        "            'optimizer_state_dict': optimizer.state_dict(),\n",
        "            'loss': criterion,\n",
        "            'epoch_acc': epoch_acc,\n",
        "            'epoch_loss': epoch_loss,\n",
        "            }, PATH)\n",
        "      print('!!! The trained model is saved !!!') # Make sure you have enough space on google drive\n",
        "\n",
        "    # Early stopper\n",
        "    if running_loss < stop_at_loss:\n",
        "      print('Training is stopped at [Epoch %d] as loss is already very low (%5f)!' %(epoch+1, running_loss))\n",
        "      break\n",
        "\n",
        "print('\\n===== Finished Training & Validating =====')\n"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[MM17-WeiboRumorSet/nonrumor_images]: 5318 image loaded.\n",
            "[MM17-WeiboRumorSet/rumor_images]: 7954 image loaded.\n",
            "Total no. of train set images:  10617\n",
            "Total no. of test set images:  2655\n",
            "classes: ['nonrumor_images', 'rumor_images']\n",
            "\n",
            "===== Start a New Training ... =====\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 1/331] Running Loss: 0.694848  Running Acc: 0.500000\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 21/331] Running Loss: 0.667883  Running Acc: 0.611607\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 41/331] Running Loss: 0.659529  Running Acc: 0.614329\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 61/331] Running Loss: 0.646279  Running Acc: 0.638832\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 81/331] Running Loss: 0.636788  Running Acc: 0.651235\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 101/331] Running Loss: 0.627951  Running Acc: 0.662438\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 121/331] Running Loss: 0.622818  Running Acc: 0.664256\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 141/331] Running Loss: 0.614326  Running Acc: 0.672651\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 161/331] Running Loss: 0.608427  Running Acc: 0.676048\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 181/331] Running Loss: 0.599782  Running Acc: 0.683356\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 201/331] Running Loss: 0.593850  Running Acc: 0.688588\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 221/331] Running Loss: 0.586977  Running Acc: 0.693298\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 241/331] Running Loss: 0.577665  Running Acc: 0.701245\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 261/331] Running Loss: 0.570985  Running Acc: 0.707256\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 281/331] Running Loss: 0.564636  Running Acc: 0.710298\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 301/331] Running Loss: 0.560011  Running Acc: 0.712832\n",
            "MVNN_wout_freq: [Epoch 1] [Iter 321/331] Running Loss: 0.554191  Running Acc: 0.718069\n",
            "Training: Loss = 0.554191, Acc = 0.718069\n",
            "Training Time:      5.180 mins\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 1/331] Running Loss: 0.528520  Running Acc: 0.812500\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 21/331] Running Loss: 0.427442  Running Acc: 0.812500\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 41/331] Running Loss: 0.424620  Running Acc: 0.809451\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 61/331] Running Loss: 0.417471  Running Acc: 0.816598\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 81/331] Running Loss: 0.406203  Running Acc: 0.824460\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 101/331] Running Loss: 0.405098  Running Acc: 0.822092\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 121/331] Running Loss: 0.398076  Running Acc: 0.824897\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 141/331] Running Loss: 0.394318  Running Acc: 0.826684\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 161/331] Running Loss: 0.393157  Running Acc: 0.826087\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 181/331] Running Loss: 0.394242  Running Acc: 0.825104\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 201/331] Running Loss: 0.391839  Running Acc: 0.826959\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 221/331] Running Loss: 0.393546  Running Acc: 0.825509\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 241/331] Running Loss: 0.392887  Running Acc: 0.825467\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 261/331] Running Loss: 0.391925  Running Acc: 0.826030\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 281/331] Running Loss: 0.392735  Running Acc: 0.825289\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 301/331] Running Loss: 0.393969  Running Acc: 0.823505\n",
            "MVNN_wout_freq: [Epoch 2] [Iter 321/331] Running Loss: 0.393201  Running Acc: 0.823403\n",
            "Training: Loss = 0.393201, Acc = 0.823403\n",
            "Training Time:      5.214 mins\n",
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] [Epoch 2]  10 / 82 batches tested\n",
            "[Test] [Epoch 2]  20 / 82 batches tested\n",
            "[Test] [Epoch 2]  30 / 82 batches tested\n",
            "[Test] [Epoch 2]  40 / 82 batches tested\n",
            "[Test] [Epoch 2]  50 / 82 batches tested\n",
            "[Test] [Epoch 2]  60 / 82 batches tested\n",
            "[Test] [Epoch 2]  70 / 82 batches tested\n",
            "[Test] [Epoch 2]  80 / 82 batches tested\n",
            "[Test] [Epoch 2] 82 / 82 batches tested. Test Loss: 0.431702\n",
            "Accuracy: 0.8079268292682927\n",
            "Balanced Accuracy: 0.795263696923117\n",
            "Confusion Matrix:\n",
            " [[ 767  280]\n",
            " [ 224 1353]]\n",
            "Cohen Kappa Score: 0.5958830981758001\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.77      0.73      0.75      1047\n",
            "       rumor       0.83      0.86      0.84      1577\n",
            "\n",
            "    accuracy                           0.81      2624\n",
            "   macro avg       0.80      0.80      0.80      2624\n",
            "weighted avg       0.81      0.81      0.81      2624\n",
            "\n",
            "\n",
            "drive/My Drive/Colab Notebooks/trained_models/MVNN_wout_freq_MAXepoch300_batch32_lr0.0001_seed0.pth\n",
            "!!! The trained model is saved !!!\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 1/331] Running Loss: 0.247962  Running Acc: 0.906250\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 21/331] Running Loss: 0.281261  Running Acc: 0.888393\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 41/331] Running Loss: 0.258886  Running Acc: 0.907012\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 61/331] Running Loss: 0.252805  Running Acc: 0.908811\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 81/331] Running Loss: 0.241014  Running Acc: 0.911651\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 101/331] Running Loss: 0.233978  Running Acc: 0.913057\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 121/331] Running Loss: 0.233264  Running Acc: 0.914773\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 141/331] Running Loss: 0.232302  Running Acc: 0.916002\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 161/331] Running Loss: 0.233736  Running Acc: 0.914790\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 181/331] Running Loss: 0.235029  Running Acc: 0.913329\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 201/331] Running Loss: 0.235020  Running Acc: 0.911847\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 221/331] Running Loss: 0.239847  Running Acc: 0.907664\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 241/331] Running Loss: 0.240077  Running Acc: 0.907547\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 261/331] Running Loss: 0.242746  Running Acc: 0.904933\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 281/331] Running Loss: 0.243702  Running Acc: 0.903692\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 301/331] Running Loss: 0.244696  Running Acc: 0.903551\n",
            "MVNN_wout_freq: [Epoch 3] [Iter 321/331] Running Loss: 0.242882  Running Acc: 0.904303\n",
            "Training: Loss = 0.242882, Acc = 0.904303\n",
            "Training Time:      5.237 mins\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 1/331] Running Loss: 0.120575  Running Acc: 0.968750\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 21/331] Running Loss: 0.132706  Running Acc: 0.953869\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 41/331] Running Loss: 0.126314  Running Acc: 0.955030\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 61/331] Running Loss: 0.121669  Running Acc: 0.955943\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 81/331] Running Loss: 0.123289  Running Acc: 0.956404\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 101/331] Running Loss: 0.125693  Running Acc: 0.954517\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 121/331] Running Loss: 0.122576  Running Acc: 0.957645\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 141/331] Running Loss: 0.123772  Running Acc: 0.956782\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 161/331] Running Loss: 0.121021  Running Acc: 0.957298\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 181/331] Running Loss: 0.123891  Running Acc: 0.955974\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 201/331] Running Loss: 0.124311  Running Acc: 0.955690\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 221/331] Running Loss: 0.124242  Running Acc: 0.956024\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 241/331] Running Loss: 0.124085  Running Acc: 0.955913\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 261/331] Running Loss: 0.126349  Running Acc: 0.954741\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 281/331] Running Loss: 0.126555  Running Acc: 0.954515\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 301/331] Running Loss: 0.129361  Running Acc: 0.952554\n",
            "MVNN_wout_freq: [Epoch 4] [Iter 321/331] Running Loss: 0.130481  Running Acc: 0.952005\n",
            "Training: Loss = 0.130481, Acc = 0.952005\n",
            "Training Time:      5.241 mins\n",
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] [Epoch 4]  10 / 82 batches tested\n",
            "[Test] [Epoch 4]  20 / 82 batches tested\n",
            "[Test] [Epoch 4]  30 / 82 batches tested\n",
            "[Test] [Epoch 4]  40 / 82 batches tested\n",
            "[Test] [Epoch 4]  50 / 82 batches tested\n",
            "[Test] [Epoch 4]  60 / 82 batches tested\n",
            "[Test] [Epoch 4]  70 / 82 batches tested\n",
            "[Test] [Epoch 4]  80 / 82 batches tested\n",
            "[Test] [Epoch 4] 82 / 82 batches tested. Test Loss: 0.561417\n",
            "Accuracy: 0.8163109756097561\n",
            "Balanced Accuracy: 0.8110085190733427\n",
            "Confusion Matrix:\n",
            " [[ 823  226]\n",
            " [ 256 1319]]\n",
            "Cohen Kappa Score: 0.619060699430444\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.76      0.78      0.77      1049\n",
            "       rumor       0.85      0.84      0.85      1575\n",
            "\n",
            "    accuracy                           0.82      2624\n",
            "   macro avg       0.81      0.81      0.81      2624\n",
            "weighted avg       0.82      0.82      0.82      2624\n",
            "\n",
            "\n",
            "drive/My Drive/Colab Notebooks/trained_models/MVNN_wout_freq_MAXepoch300_batch32_lr0.0001_seed0.pth\n",
            "!!! The trained model is saved !!!\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 1/331] Running Loss: 0.082251  Running Acc: 0.968750\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 21/331] Running Loss: 0.083818  Running Acc: 0.970238\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 41/331] Running Loss: 0.081644  Running Acc: 0.972561\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 61/331] Running Loss: 0.081583  Running Acc: 0.971824\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 81/331] Running Loss: 0.083135  Running Acc: 0.969522\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 101/331] Running Loss: 0.082375  Running Acc: 0.971535\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 121/331] Running Loss: 0.080688  Running Acc: 0.972107\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 141/331] Running Loss: 0.078295  Running Acc: 0.973183\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 161/331] Running Loss: 0.079577  Running Acc: 0.972244\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 181/331] Running Loss: 0.081990  Running Acc: 0.971340\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 201/331] Running Loss: 0.082044  Running Acc: 0.971393\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 221/331] Running Loss: 0.082524  Running Acc: 0.971012\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 241/331] Running Loss: 0.080627  Running Acc: 0.971214\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 261/331] Running Loss: 0.082196  Running Acc: 0.970546\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 281/331] Running Loss: 0.081588  Running Acc: 0.971197\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 301/331] Running Loss: 0.082559  Running Acc: 0.970619\n",
            "MVNN_wout_freq: [Epoch 5] [Iter 321/331] Running Loss: 0.083147  Running Acc: 0.970405\n",
            "Training: Loss = 0.083147, Acc = 0.970405\n",
            "Training Time:      5.282 mins\n",
            "Training is stopped at [Epoch 5] as loss is already very low (0.083147)!\n",
            "\n",
            "===== Finished Training & Validating =====\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6jQUG4hOccu"
      },
      "source": [
        "# Training graph"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jfdMzsbAOcB-",
        "outputId": "be54a0e7-cf5d-4c86-dc77-49f3d9a1c42c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 308
        }
      },
      "source": [
        "x = list(range(1, epoch+2))\n",
        "# print(x)\n",
        "# print(epoch_acc)\n",
        "\n",
        "fig, (ax1, ax2) = plt.subplots(2, 1)\n",
        "fig.suptitle('Training metrics (%s)' %(modelname))    \n",
        "ax1.plot(x, epoch_acc, 'o-')\n",
        "ax1.set_ylabel('Accuracy')\n",
        "ax1.set_xticks(list(range(1, epoch+2, 2)))\n",
        "\n",
        "ax2.plot(x, epoch_loss, '.-')\n",
        "ax2.set_xlabel('Epoch')\n",
        "ax2.set_ylabel('Loss')\n",
        "ax2.set_xticks(list(range(1, epoch+2, 2)))\n",
        "\n",
        "figname = (\"drive/My Drive/Colab Notebooks/trained_models/\"+ modelname + \"_epoch\" + str(epoch+1)\n",
        "         + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_' + 'seed' + str(seed_no) + '_'\n",
        "         + datetime.today().strftime('%Y-%m-%d') + \"v4.pdf\")\n",
        "\n",
        "plt.savefig(figname, bbox_inches='tight')\n"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gC1SLtQjDXck"
      },
      "source": [
        "# Save the trained model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ZjCLDm-DWt6",
        "outputId": "0bf26264-34c6-4011-de3b-835870a5d365",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Specify a path to your local drive\n",
        "PATH = ('drive/My Drive/Colab Notebooks/trained_models/' + modelname + \"_epoch\" + str(epoch+1)\n",
        "         + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_' + 'seed' + str(seed_no) + '_'\n",
        "         + datetime.today().strftime('%Y-%m-%d') + \".pt\")\n",
        "print(PATH)\n",
        "\n",
        "# Save the trained model\n",
        "torch.save(model, PATH)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "drive/My Drive/Colab Notebooks/trained_models/MVNN_wout_freq_epoch5_batch32_lr0.0001_seed0_2020-11-04.pt\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zYR3Z7xgYU18"
      },
      "source": [
        "## Load the trained model from google drive share id"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cpZXxMnBeXbU"
      },
      "source": [
        "# Download the trained full MVNN model\n",
        "# !gdown --id 1-1Io_bGiir9Wq4cgwzkdNrVzseRYX4pa\n",
        "# PATH = '/content/MVNN_epoch16_batch32_lr0.0001_seed0_2020-10-31.pt'\n",
        "\n",
        "# Download the trained MVNN without frequency\n",
        "# !gdown --id 1lAYnZ4OZbivnlkkkzWpc9F6GTLRqpRjO\n",
        "# PATH = '/content/MVNN_wout_freq_epoch19_batch32_lr0.0001_seed0_2020-10-31.pt'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MC2rwHwoYcin"
      },
      "source": [
        "model = torch.load(PATH)"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNsR5NuQYnL3",
        "outputId": "7cb6fe04-607a-4932-89bf-12d2580fe253",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "report_every = 10\n",
        "acc, loss = 0, 0\n",
        "cnt = 0\n",
        "model.eval()\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    print('\\n===== Start Validating ... =====')\n",
        "    for data in testloader:\n",
        "        Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "        y = data[2].to(device)\n",
        "\n",
        "        # prediction\n",
        "        out = model(Xp, Xf)        \n",
        "        pred = torch.argmax(out, dim=1)\n",
        "\n",
        "        y_true.append(y)\n",
        "        y_pred.append(pred)\n",
        "\n",
        "        cnt += 1\n",
        "\n",
        "        if cnt % report_every == 0:\n",
        "            print(\"[Test] %d / %d batches tested\" % (cnt, testloader.__len__()))        \n",
        "\n",
        "    print(\"[Test] %d / %d batches tested\" % (cnt, testloader.__len__()))\n",
        "    y_true = torch.cat(y_true, dim=0)\n",
        "    y_pred = torch.cat(y_pred, dim=0)\n",
        "    target_names = ['non-rumor', 'rumor']\n",
        "    print_metrics(y_true.cpu(), y_pred.cpu(), target_names)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] 10 / 82 batches tested\n",
            "[Test] 20 / 82 batches tested\n",
            "[Test] 30 / 82 batches tested\n",
            "[Test] 40 / 82 batches tested\n",
            "[Test] 50 / 82 batches tested\n",
            "[Test] 60 / 82 batches tested\n",
            "[Test] 70 / 82 batches tested\n",
            "[Test] 80 / 82 batches tested\n",
            "[Test] 82 / 82 batches tested\n",
            "Accuracy: 0.8117378048780488\n",
            "Balanced Accuracy: 0.797647948915823\n",
            "Confusion Matrix:\n",
            " [[ 763  286]\n",
            " [ 208 1367]]\n",
            "Cohen Kappa Score: 0.6027802343746649\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.79      0.73      0.76      1049\n",
            "       rumor       0.83      0.87      0.85      1575\n",
            "\n",
            "    accuracy                           0.81      2624\n",
            "   macro avg       0.81      0.80      0.80      2624\n",
            "weighted avg       0.81      0.81      0.81      2624\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}